home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pine / ccmd / cmqst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-08-19  |  9.1 KB  |  273 lines
  1. /*
  2.  Author: Andrew Lowry
  3.  
  4.  Columbia University Center for Computing Activities, July 1986.
  5.  Copyright (C) 1986, 1987, Trustees of Columbia University in the City
  6.  of New York.  Permission is granted to any individual or institution
  7.  to use, copy, or redistribute this software so long as it is not sold
  8.  for profit, provided this copyright notice is retained.
  9. */
  10. /* cmqst
  11. **
  12. ** This module contains the standard break table and handlers for
  13. ** parsing quoted strings.  Parsing succeeds if the current input
  14. ** contains a quote, followed by an acceptable content string,
  15. ** followed by a quote and any character other than a quote.
  16. ** Doubled quotes are converted to singleton quotes.  An exception
  17. ** is when the doubled quote occurs at the beginning of the field,
  18. ** in which case an empty string is parsed.  The parsed
  19. ** string is returned, without opening or closing quotes, via
  20. ** the atom buffer.  The characters that are allowed inside the
  21. ** quoted string are precisely those that do not break in non-first
  22. ** position.  By default, this includes all printing characters.
  23. ** Note that this default implies that question marks lose their
  24. ** standard actions.
  25. **
  26. ** The first-position break array can be used to indicate which
  27. ** characters are allowed to serve as quotes.  If the first character
  28. ** is any of these characters, it becomes the quote character for
  29. ** the field, and the ASCII quote character (") is treated as an
  30. ** ordinary character.  Thus, when quote is not the field delimiter,
  31. ** it need not be doubled, but the field delimiter must be doubled.
  32. ** For example, the following would yield equivalent results:
  33. **
  34. **        "The character, ""\,"" is called ""back-slash."""
  35. **        \The character, "\\," is called "back-slash."\
  36. **
  37. ** By default, the ASCII quote and apostrophe are the only
  38. ** characters allowed to be quotes (" and ').
  39. **
  40. ** Full completion, when invoked immediately following a singleton quote,
  41. ** inserts a space after the quote.  Otherwise it beeps.  Partial completion
  42. ** always beeps.  The standard help string is "Quoted string," unless
  43. ** the first-position break array is not identical to the standard,
  44. ** in which case "Delimited string" is used instead.  If the delimiter
  45. ** is already present in the buffer, the message "String terminated by 
  46. ** 'x'" is used, where x is the delimiter.
  47. **/
  48.  
  49. #define    QSTERR            /* declare cmqst parse errors here */
  50.  
  51. #include "ccmdlib.h"        /* get ccmd package symbols */
  52. #include "cmfncs.h"        /* and internal symbols */
  53.  
  54. /* Forward declarations of handler routines */
  55.  
  56. int qstprs(), qsthlp(), qstcplt();
  57.  
  58. static brktab qstbrk = {
  59.   {                    /* chars that can serve as quote */
  60.     0xff, 0xff, 0xff, 0xff, 0xde, 0xff, 0xff, 0xff, /* allow " and ' */
  61.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
  62.   },
  63.   {                    /* chars that can be in strings */
  64.     0xff, 0xbf, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, /* tab and all */
  65.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01  /*  printable chars */
  66.   }
  67. };
  68.  
  69. ftspec ft_qst = { qstprs, qsthlp, qstcplt, 0, &qstbrk }; /* handler structure */
  70.  
  71.  
  72.  
  73. /* qstprs - If the current input contains a proper quoted string,
  74. ** copy it into the atom buffer and return, with the CSB flag set
  75. ** to prevent automatic atom buffer copying.
  76. **/
  77.  
  78. PASSEDSTATIC int
  79. qstprs(text,textlen,fdbp,parselen,value)
  80. char *text;
  81. int textlen,*parselen;
  82. fdb *fdbp;
  83. pval *value;
  84. {
  85.   char quote;            /* character used as quote */
  86.   int qstlen;            /* length of (undoubled) quoted string */
  87.   char *term;            /* pointer to char after closing quote */
  88.   int ret;            /* returned by auxiliary routine */
  89.   int i;
  90.  
  91.   ret = fndqst(text,textlen,fdbp,"e,&qstlen,&term); /* find the string */
  92.   if (ret != CMxOK)
  93.     return(ret);        /* propagate errors */
  94.  
  95.   if (term == NULL)        /* not terminated...  */
  96.     return(CMxINC);        /* they might double final quote */
  97.  
  98.   if ((qstlen+1) > cmcsb._cmabc)
  99.     return(CMxAOVF);        /* no room to return string */
  100.  
  101.   *parselen = term - text;    /* set buffer consumption */
  102.  
  103.   for (i = 0; i < qstlen; i++)    /* copy chars to atom buffer */
  104.     if (*(++text) == quote)    /* quote char? (will fail if quoted) */
  105.       cmcsb._cmabp[i] = *(++text) & CC_CHR; /* yes, must be doubled */
  106.     else
  107.       cmcsb._cmabp[i] = *text & CC_CHR; /* otherwise copy it in */
  108.   cmcsb._cmabp[qstlen] = NULCHAR; /* tie off with null character */
  109.   cmcsb._cmflg |= CM_NAC;    /* don't let ccmd copy to atom */
  110.   value->_pvstr = cmcsb._cmabp;
  111.   return(CMxOK);        /* all done */
  112. }
  113.  
  114.  
  115.  
  116. /* qsthlp - Decide what the quote situation is, then give the appropriate
  117. ** message.
  118. **/
  119.  
  120. PASSEDSTATIC int
  121. qsthlp(text,textlen,fdbp,cust)
  122. char *text;
  123. int textlen,cust;
  124. fdb *fdbp;
  125. {
  126.   brktab *btab;            /* break table in use */
  127.   int qmsg = TRUE;        /* use "Quote" message if TRUE */
  128.   int i;
  129.   char c;
  130.  
  131.   if (fdbp->_cmbrk != NULL)
  132.     btab = fdbp->_cmbrk;    /* get user break table */
  133.   else
  134.     btab = &qstbrk;
  135.  
  136.   for (i = 0; i < 16; i++)    /* check for matching 1st char brk array */
  137.     if (btab->_br1st[i] != qstbrk._br1st[i]) {
  138.       qmsg = FALSE;        /* no match - use other message */
  139.       break;
  140.     }
  141.     
  142.   if (qmsg)            /* standard quote set? */
  143.     cmxputs("quoted string");    /* use standard message */
  144.   else if (textlen == 0)    /* nonstandard quotes... delimiter given? */
  145.     cmxputs("delimited string"); /* use alternate message */
  146.   else {            /* quote known... include it in message */
  147.     cmxputs("string terminated by "); /* beginning of message */
  148.     c = *text & CC_CHR;    /* get quote character */
  149.     if (c == TAB)
  150.       cmxputs("tab");        /* take care of some special cases */
  151.     else if (c == NEWLINE)
  152.       cmxputs("newline");
  153.     else if (c == '\'')
  154.       cmxputs("\" \' \"");
  155.     else {
  156.       cmxputc('\'');        /* standard case... surround with squotes */
  157.       cmechx(c);
  158.       cmxputc('\'');
  159.     }
  160.   }
  161.   return(CMxOK);
  162. }
  163.  
  164.  
  165.  
  166. /* qstcplt - Beep for anything but full completion when a proper
  167. ** quoted string is there but not yet terminated.  In that case,
  168. ** if the quote character is a space, beep.  Else return a single
  169. ** space as completion text.
  170. **/
  171.  
  172. PASSEDSTATIC int
  173. qstcplt(text,textlen,fdbp,full,cplt,cpltlen)
  174. char *text,**cplt;
  175. int textlen,full,*cpltlen;
  176. fdb *fdbp;
  177. {
  178.   char quote;            /* character used as quote */
  179.   int qstlen;            /* length of (undoubled) quoted string */
  180.   char *term;            /* pointer to char after closing quote */
  181.   int ret;            /* returned by auxiliary routine */
  182.  
  183.   ret = fndqst(text,textlen,fdbp,"e,&qstlen,&term); /* find the string */
  184.  
  185.   *cplt = NULL;            /* no completion text */
  186.   if (!full || (ret == CMxINC)) /* partial completion or no closing quote? */
  187.     return(CMP_BEL);        /* then just beep at them */
  188.   else if (quote == SPACE)    /* also beep if quote char is space */
  189.     return(CMP_BEL);
  190.   else
  191.     return(CMP_SPC | CMP_GO);    /* otherwise, stuff a space and wakeup */
  192. }
  193.  
  194.  
  195.  
  196. /* fndqst - Auxiliary routine for quoted string handlers.
  197. **
  198. ** Purpose:
  199. **   Isolate a quoted string in the given text.
  200. **
  201. ** Input arguments:
  202. **   text - A pointer to the text to be scanned.
  203. **   textlen - The number of chars to be scanned.
  204. **   fdbp - A pointer to the FDB for the current parse.
  205. **
  206. ** Output arguments:
  207. **   quote - The character being used for quoting.
  208. **   qstlen - The number of chars in the string (counting doubled quot
  209. **     characters only once, and not counting opening and closing
  210. **     quotes).
  211. **   term - A pointer to the character terminating the field, that is,
  212. **     following the closing quote (not the closing quote itself).  NULL
  213. **     if there is no such character (the text ran out).
  214. **
  215. ** Returns: Standard return code.
  216. **/
  217.  
  218. static int
  219. fndqst(text,textlen,fdbp,quote,qstlen,term)
  220. char *text, *quote, **term;
  221. int textlen, *qstlen;
  222. fdb *fdbp;
  223. {
  224.   int qseen = FALSE;        /* TRUE when last char was a quote char */
  225.   char c;            /* characters from text */
  226.   brktab *btab;            /* break table for the parse */
  227.  
  228.   if (textlen == 0)
  229.     return(CMxINC);        /* nothing to parse */
  230.  
  231.   if ((btab = fdbp->_cmbrk) == NULL) /* get supplied break table */
  232.     btab = &qstbrk;        /* or use default */
  233.  
  234.   *qstlen = 0;            /* start length count at zero */
  235.   *quote = *text++;        /* pick up quote character */
  236.   textlen--;            /* and count it */
  237.   
  238.   if ((*quote & CC_QUO) == 0) {    /* first char unquoted? */
  239.     if (BREAK1(btab,*quote))    /* and a 1st position break char? */
  240.       return(QSTxQC);        /* bad quote character */
  241.   }
  242.   else
  243.     *quote &= CC_CHR;        /* turn off quoted flag in returned char */
  244.  
  245.   while (textlen-- > 0) {    /* scan characters */
  246.     c = *text++;        /* pick up next char */
  247.     if ((c & CC_CHR) == *quote) /* quote character? */
  248.       if (qseen) {        /* second in a doubled pair? */
  249.     (*qstlen)++;        /* yup, bump length count */
  250.     qseen = FALSE;        /* and turn off flag */
  251.       }
  252.       else
  253.     qseen = TRUE;        /* by itself - set flag */
  254.  
  255.     else            /* not a quote */
  256.       if (qseen) {        /* following a quote? */
  257.     *term = text-1;        /* yup, it's the terminator */
  258.     return(CMxOK);        /* so we're done */
  259.       }
  260.       else {            /* otherwise part of the string */
  261.     if ((c & CC_QUO) == 0)    /* if it's unquoted */
  262.           if (BREAKR(btab,c))    /* make sure it's allowed */
  263.         return(QSTxBC);
  264.     (*qstlen)++;        /* ok, bump count */
  265.       }
  266.   }
  267.   *term = NULL;            /* fall thru when no terminator present */
  268.   if (qseen)
  269.     return(CMxOK);        /* last char was quote - it's complete */
  270.   else
  271.     return(CMxINC);        /* else still waiting */
  272. }
  273.